package com.future;

/**
 * Description:
 * 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
 * <p>
 * 如果剩余字符少于 k 个，则将剩余字符全部反转。
 * 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
 * <p>
 * 示例 1：
 * <p>
 * 输入：s = "abcdefg", k = 2
 * 输出："bacdfeg"
 * 示例 2：
 * <p>
 * 输入：s = "abcd", k = 2
 * 输出："bacd"
 * <p>
 * 提示：
 * <p>
 * 1 <= s.length <= 104
 * s 仅由小写英文组成
 * 1 <= k <= 104
 * <p>
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/reverse-string-ii
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 * @author weiruibai.vendor
 * Date: 2021/9/30 15:55
 */
public class Solution_reverseStr_541 {

    public static void main(String[] args) {
        String s = "abcdefg";
        s = "abcd";
        s = "abcdefghi";// bacdfe
        int k = 2;
        s = "abcdefgh";
        k = 3;
        System.out.println("原始：" + s);
        System.out.println("结果：" + reverseStr(s, k));
    }

    public static String reverseStr(String s, int k) {
        if (s == null || s.trim().length() == 0) {
            return s;
        }
        int N = s.length();
        int cycleTimes = 1;
        char[] chars = s.toCharArray();
        /**
         * 每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符
         */
        while (N >= 2 * k) {
            int start = (cycleTimes - 1) * 2 * k;
            int end = start + k - 1;
            while (start < end) {
                char c = chars[start];
                chars[start] = chars[end];
                chars[end] = c;
                start++;
                end--;
            }
            N -= 2 * k;
            cycleTimes++;
            s = String.valueOf(chars);
        }
        /**
         * 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样
         */
        while (N >= k) {
            int start = (cycleTimes - 1) * 2 * k;
            int end = start + k - 1;
            while (start < end) {
                char c = chars[start];
                chars[start] = chars[end];
                chars[end] = c;

                start++;
                end--;
            }
            N -= 2 * k;
            cycleTimes++;
            s = String.valueOf(chars);
        }
        /**
         * 剩余字符少于 k 个，则将剩余字符全部反转
         */
        if (N > 0) {
            int start = (cycleTimes - 1) * 2 * k;
            int end = start + N - 1;
            while (start < end) {
                char c = chars[start];
                chars[start] = chars[end];
                chars[end] = c;

                start++;
                end--;
            }
            N -= 2 * k;
            cycleTimes++;
            s = String.valueOf(chars);
        }
        return s;
    }


}
